home *** CD-ROM | disk | FTP | other *** search
/ Network Supervisor's Toolkit / Network Supervisor's Toolkit.iso / tools / lu62 / sendbm.c < prev    next >
C/C++ Source or Header  |  1996-07-10  |  5KB  |  172 lines
  1.  /*
  2.  
  3.                  SEND_DATA_BUFFER_MANAGEMENT
  4.                          (SENDBM)
  5.  
  6.      Process the data which then will be sent to HS.
  7.  
  8.      INPUT : Pointer to verb, pointer to RCB.
  9.  
  10.  CopyRight 1995. Nicholas Poljakov all rights reserved.
  11.  
  12.  */
  13.  
  14. #include <sendat.h>
  15. #include <state1.h>
  16. #include <rcb.h>
  17. #include <stdio.h>
  18. #include <malloc.h>
  19. #include <string.h>
  20. int sk_r_wt(void *);
  21. int setrc(void *, void *);
  22. int sendhsf(void *);
  23. int sendhs(void *);
  24. int sendbm(void *, void *);
  25. int sendat(void *);
  26. int rtsend(void *);
  27. unsigned long rmfmh5(void *, void *);
  28. int recwait(void *);
  29. int rcvru(void *, void *);
  30. int rcvhs(void *, void *, void *, void *);
  31. int ralloc(void *, void *);
  32. int psrm(int, void *, void *);
  33. int ps_conv(int, void *);
  34. int proterr(void *, unsigned long);
  35. int preptrcv(void *, void *);
  36. int post_rcb(void *);
  37. struct repass *postopen(void *);
  38. int phsrec(void *);
  39. int pfmh5(void *);
  40. int opndst(void *);
  41. int obtsess(void *, unsigned char);
  42. int Lrf_handler(void *);
  43. int get_sess(void *, void *);
  44. int get_attr(void *);
  45. int fsm_error(unsigned char, void *);
  46. int fsm_conv(unsigned char, unsigned char, void *);
  47. int flush (void *);
  48. int dcp(void *);
  49. int dealloc(void *);
  50. int crtp(void *);
  51. int conv(void *);
  52. int chkparm(void *, void *);
  53. int check_end(unsigned int, void *);
  54. struct rqb *call_appl(void *);
  55. int buffmng(unsigned char, void *, void *, void *, unsigned, unsigned char, unsigned);
  56. unsigned long attltck(void *);
  57. unsigned long attacheck(void *);
  58. char *cgetmem(int, int);
  59. int sendhsf(void *);
  60. int opndst(void *);
  61. int alloc_rcb(void *, void *);
  62. int allocate(void *);
  63. int clsdst(void *);
  64.  
  65. sendbm(pptr, p_rcb)
  66. struct send_data *pptr;
  67. struct rcb *p_rcb;
  68. {
  69.        char *p;
  70.        int  lt;
  71.        int  rest;
  72.        char *p_ll;
  73.        unsigned short l_str;
  74.        char *p1;
  75.        int i;
  76.        unsigned short *m;
  77.        char code;
  78.        char *buff;
  79.        unsigned int type;
  80.        unsigned char dsc;
  81.        unsigned char temp;
  82.  
  83. #if OS_TYPE == 1
  84. /*********  Trace facility **********/
  85. unsigned int rtype;   /* type of record */
  86. unsigned int pnum;    /* point number */
  87. char pname[8];        /* name of module */
  88. char *drec;       /* record for dump */
  89. int  lenr;            /* record length */
  90.  
  91. rtype = INPROC;
  92. strcpy(pname, "sendbm");
  93. pnum = 1;
  94. drec = pptr;
  95. lenr = sizeof(struct send_data);
  96. gtf(rtype, pname, pnum, drec, lenr);
  97. /***********************************/
  98. #endif
  99.  
  100.        p_ll = pptr->data_addr;
  101.        m = (short *)pptr -> data_addr;
  102.        l_str = *m;
  103.        p1 = &l_str;
  104.  
  105.        l_str &= 0x7fff;   /* turn off high bit */
  106.  
  107.        p = pptr->data_addr;
  108.        lt = pptr -> data_lt;
  109.        code = 'A';
  110.        buff = &((*p_rcb).first_out);
  111.  
  112.        if (p_rcb->send_ll_remainder == 0) {
  113.  
  114.       /*    Make the LL-processing;
  115.        *    Check if LL is wrong (wrong values are the following:
  116.        *     X'0000',X'8000',X'8001'.
  117.        *     Value X'0001' is right for PS header only.
  118.        */
  119.       m = (short *)pptr-> data_addr;
  120.            switch (*m) {
  121.                           case 0x0000:
  122.                       /*  case 0x0001:  */
  123.                           case 0x8000:
  124.                           case 0x8001:
  125.                                           goto bad_return;
  126.                        }
  127.            if ((pptr->data_lt) > l_str)
  128.                 goto bad_return;
  129.            p_rcb->send_ll_remainder = l_str - pptr->data_lt;
  130.            temp = p[0];  /* for compatibility */
  131.            p[0] = p[1];  /* whith             */
  132.            p[1] = temp;  /* IBM mainframe     */
  133.        }
  134.        else
  135.             {
  136.                 if (pptr->data_lt > p_rcb->send_ll_remainder)
  137.                         goto bad_return;  /* One GDS per send */
  138.                         p_rcb->send_ll_remainder -= pptr->data_lt;
  139.             }
  140.        rest = lt;
  141.        type = Send_data;
  142.        do {
  143.         rest -= MAX_RU;
  144.         if (rest > 0) {
  145.             lt = MAX_RU;
  146.             dsc = 1;
  147.         }
  148.         else
  149.                 {
  150.                     lt = rest + MAX_RU;
  151.                     rest = 0;
  152.                     dsc = 0;
  153.                 }
  154.         if ((p1 = malloc(lt)) == NULL) {
  155.             pptr -> prim_rc = INCOMPLETE;
  156.             return (0);
  157.         }
  158.         memcpy(p1, p_ll, lt);
  159.         p_ll += lt;
  160.         buffmng(code, p1, buff, p_rcb, lt, dsc, type);
  161.        } while (rest != 0);
  162.        /*
  163.        sendhs(p_rcb);
  164.         */
  165.        goto ok_return;
  166. bad_return :
  167.              pptr->prim_rc = PARAMETR_CHECK;
  168.              pptr->sec_rc = BAD_LL;
  169. ok_return :
  170.              return(0);
  171. }
  172.